/**
 * 金额工具函数
 */

/**
 * 金额转换选项
 */
export interface AmountConvertOptions {
  /** 保留小数位数，默认2位 */
  precision?: number;
  /** 是否显示单位，默认true */
  showUnit?: boolean;
  /** 自定义单位文本 */
  unitText?: {
    wan?: string;
    yi?: string;
  };
}

/**
 * 将金额转换为万、亿单位
 * @param amount 原始金额
 * @param options 转换选项
 * @returns 转换后的金额字符串
 */
export function formatAmountUnit(amount: number | string, options: AmountConvertOptions = {}): string {
  const {
    precision = 2,
    showUnit = true,
    unitText = { wan: '万', yi: '亿' }
  } = options;

  // 转换为数字
  const num = typeof amount === 'string' ? parseFloat(amount) : amount;
  
  // 处理无效数字
  if (isNaN(num)) {
    return '0';
  }

  // 处理负数
  const isNegative = num < 0;
  const absNum = Math.abs(num);

  let result = '';
  let convertedNum = 0;
  let unit = '';

  if (absNum >= 100000000) {
    // 大于等于1亿，转换为亿
    convertedNum = absNum / 100000000;
    unit = unitText.yi || '亿';
  } else if (absNum >= 10000) {
    // 大于等于1万，转换为万
    convertedNum = absNum / 10000;
    unit = unitText.wan || '万';
  } else {
    // 小于1万，不转换
    convertedNum = absNum;
    unit = '';
  }

  // 格式化数字
  const formattedNum = convertedNum.toFixed(precision);
  
  // 移除末尾的0和小数点
  const cleanedNum = parseFloat(formattedNum).toString();
  
  // 组装结果
  result = (isNegative ? '-' : '') + cleanedNum + (showUnit ? unit : '');
  
  return result;
}

/**
 * 将金额转换为万单位
 * @param amount 原始金额
 * @param precision 保留小数位数，默认2位
 * @returns 转换后的金额字符串
 */
export function formatAmountToWan(amount: number | string, precision: number = 2): string {
  return formatAmountUnit(amount, {
    precision,
    showUnit: true,
    unitText: { wan: '万', yi: '万' } // 统一使用万作为单位
  });
}

/**
 * 将金额转换为亿单位
 * @param amount 原始金额
 * @param precision 保留小数位数，默认2位
 * @returns 转换后的金额字符串
 */
export function formatAmountToYi(amount: number | string, precision: number = 2): string {
  const num = typeof amount === 'string' ? parseFloat(amount) : amount;
  
  if (isNaN(num)) {
    return '0';
  }

  const isNegative = num < 0;
  const absNum = Math.abs(num);
  const convertedNum = absNum / 100000000;
  
  const formattedNum = convertedNum.toFixed(precision);
  const cleanedNum = parseFloat(formattedNum).toString();
  
  return (isNegative ? '-' : '') + cleanedNum + '亿';
}

/**
 * 智能格式化金额，自动选择合适的单位
 * @param amount 原始金额
 * @param precision 保留小数位数，默认2位
 * @returns 转换后的金额字符串
 */
export function smartFormatAmount(amount: number | string, precision: number = 2): string {
  const num = typeof amount === 'string' ? parseFloat(amount) : amount;
  
  if (isNaN(num)) {
    return '0';
  }

  const absNum = Math.abs(num);
  
  if (absNum >= 100000000) {
    // 大于等于1亿，使用亿
    return formatAmountUnit(amount, { precision, unitText: { yi: '亿' } });
  } else if (absNum >= 10000) {
    // 大于等于1万，使用万
    return formatAmountUnit(amount, { precision, unitText: { wan: '万' } });
  } else {
    // 小于1万，不转换单位
    return num.toFixed(precision).replace(/\.?0+$/, '');
  }
}

/**
 * 获取金额的数值部分（不含单位）
 * @param amount 原始金额
 * @param unit 目标单位：'wan' | 'yi' | 'yuan'
 * @param precision 保留小数位数，默认2位
 * @returns 转换后的数值
 */
export function getAmountValue(amount: number | string, unit: 'wan' | 'yi' | 'yuan' = 'yuan', precision: number = 2): number {
  const num = typeof amount === 'string' ? parseFloat(amount) : amount;
  
  if (isNaN(num)) {
    return 0;
  }

  let result = 0;
  
  switch (unit) {
    case 'wan':
      result = num / 10000;
      break;
    case 'yi':
      result = num / 100000000;
      break;
    case 'yuan':
    default:
      result = num;
      break;
  }
  
  return parseFloat(result.toFixed(precision));
}